
# Import necessary for the projects
import os
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt


# Download the dataset from github
!git clone https://github.com/congnghia0609/ntc-scv
!unzip ./ntc-scv/data/data_test.zip -d ../data
!unzip ./ntc-scv/data/data_train.zip -d ../data
!rm -rf ./ntc-scv


# Define function to read data from file
def load_data_from_path(folder_path):
    examples = []
    for label in os.listdir(folder_path):
        full_path = os.path.join(folder_path, label)
        for file_name in os.listdir(full_path):
            file_path = os.path.join(full_path, file_name)
            with open(file_path, "r", encoding='utf-8') as f:
                linens = f.readlines()
            sentence = " ".join(linens)
            if label == "neg":
                label = 0
            if label == "pos":
                label = 1
            data = {
                'sentence'  : sentence,
                'label'     : label
            }
            examples.append(data)
    return pd.DataFrame(examples)


# Declare the path to specific data folder
folder_path = {
    'train': '../data/data_train/train',
    'valid': '../data/data_train/test',
    'test' : '../data/data_test/test'
}

# Load data to corresponding variables
train_df = load_data_from_path(folder_path['train'])
valid_df = load_data_from_path(folder_path['valid'])
test_df  = load_data_from_path(folder_path['test'])


# First ten rows of the train_df dataframe
train_df.head(10)


# Summarized information of the train_df dataframe
train_df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 30000 entries, 0 to 29999
Data columns (total 2 columns):
 #   Column    Non-Null Count  Dtype 
---  ------    --------------  ----- 
 0   sentence  30000 non-null  object
 1   label     30000 non-null  int64 
dtypes: int64(1), object(1)
memory usage: 468.9+ KB


# Categories distribution for train_df dataframe
label_counts = train_df['label'].value_counts()
label_counts.plot(kind='bar')
plt.ylabel('Count')
plt.xlabel('Label')
plt.xticks(rotation=0)  
plt.title('Distribution of Labels of train_df')
plt.show()


# Length of review comments in train_df dataframe
plt.hist([len(sentence.split()) for sentence in train_df['sentence']], bins=128, range=(0, 500))
plt.title('Sentence Length Distribution in train_df')
plt.show()


# The vocabulary size and the total word count
from collections import Counter

words = []
for sentence in train_df['sentence']:
    words.extend(sentence.split())  

vocabulary = Counter(words)
len(vocabulary), len(words)

(46372, 2962235)


# Install the WordCloud library using pip
%pip install WordCloud


# Import necessary libraries
from wordcloud import WordCloud

# Aggregate all tweets from the 'sentence' column of train_df into a single list
sentences = train_df['sentence'].tolist()

# Combine the list of sentences into a single string
sentences_as_one_string = " ".join(sentences)

# Set up the plotting figure with defined figure size
plt.figure(figsize=(12, 12), dpi=600)  # Increase DPI for better resolution

# Create a Word Cloud and display it using matplotlib
wordcloud = WordCloud(background_color='white', width=800, height=400).generate(sentences_as_one_string)
plt.imshow(wordcloud, interpolation='bilinear')  
plt.axis('off')  
plt.show()


# Install langid library
%pip install langid


from langid.langid import LanguageIdentifier, model

# Define function to obtain Vietnamese comments only
def identify_vn(df):
    identifier = LanguageIdentifier.from_modelstring(model, norm_probs = True)
    not_vi_idx = set()
    THRESHOLD  = 0.9
    for idx, row in df.iterrows():
        score = identifier.classify(row["sentence"])
        if score[0] != "vi" or (score[0] == "vi" and score[1] <= THRESHOLD):
            not_vi_idx.add(idx) 
    vi_df = df[~df.index.isin(not_vi_idx)]
    not_vi_idx = df[df.index.isin(not_vi_idx)]

    return vi_df, not_vi_idx


# Classify on train dataset
train_df_vi, train_df_other = identify_vn(train_df)


# Summary of train_df_vi dataframe
train_df_vi.info()

<class 'pandas.core.frame.DataFrame'>
Index: 29736 entries, 0 to 29999
Data columns (total 2 columns):
 #   Column    Non-Null Count  Dtype 
---  ------    --------------  ----- 
 0   sentence  29736 non-null  object
 1   label     29736 non-null  int64 
dtypes: int64(1), object(1)
memory usage: 696.9+ KB


# Categories distribution for train_df_vi dataframe
label_counts = train_df_vi['label'].value_counts()
label_counts.plot(kind='bar')
plt.ylabel('Count')
plt.xlabel('Label')
plt.xticks(rotation=0)  
plt.title('Distribution of Labels of train_df_vi')
plt.show()


import re  
import string  

def preprocess_text(text):
    # Compiles a regular expression to match URLs
    url_pattern = re.compile(r'https?://\s+\wwww\.\s+')
    # Replaces URLs in the text with a single space
    text = url_pattern.sub(r" ", text)

    # Compiles a regular expression to match HTML tags
    html_pattern = re.compile(r'<[^<>]+>')
    # Replaces HTML tags in the text with a single space
    text = html_pattern.sub(" ", text)

    # List of characters to replace, combining punctuation and digits
    replace_chars = list(string.punctuation + string.digits)
    # Loop over each character in the list and replace it with a space
    for char in replace_chars:
        text = text.replace(char, " ")

    # Compiles a regular expression to match various emoticons and symbols, including flags
    emoji_pattern = re.compile("["
        u"\U0001F600-\U0001F64F"  # emoticons
        u"\U0001F300-\U0001F5FF"  # symbols & pictographs
        u"\U0001F680-\U0001F6FF"  # transport & map symbols
        u"\U0001F1E0-\U0001F1FF"  # flags (iOS)
        u"\U0001F1F2-\U0001F1F4"  # Macau flag
        u"\U0001F1E6-\U0001F1FF"  # flags
        u"\U0001F600-\U0001F64F"
        u"\U00002702-\U000027B0"
        u"\U000024C2-\U0001F251"
        u"\U0001f926-\U0001f937"
        u"\U0001F1F2"
        u"\U0001F1F4"
        u"\U0001F620"
        u"\u200d"
        u"\u2640-\u2642"
        "]+", flags=re.UNICODE)
    # Replaces emoticons and other symbols in the text with a single space
    text = emoji_pattern.sub(r" ", text)

    # Splits the text into words and rejoins them to normalize whitespace
    text = " ".join(text.split())

    # Converts all characters in the text to lowercase
    return text.lower()


# Apply the preprocess_text function to all dataset variables
train_df_vi.loc[:, 'preprocess_sentence'] = train_df_vi['sentence'].apply(preprocess_text)
valid_df.loc[:, 'preprocess_sentence'] = valid_df['sentence'].apply(preprocess_text)
test_df.loc[:, 'preprocess_sentence'] = test_df['sentence'].apply(preprocess_text)


# First ten row of train_df_vi after preprocessing
train_df_vi.head(10)


# Install torchtext for text tokenization
%pip install -q torchtext


from torchtext.data.utils import get_tokenizer

# Initialize a tokenizer for basic English text
tokenizer = get_tokenizer("basic_english")


# Example of tokenize the first sentence in the train_df_vi dataset
tokenizer(train_df_vi['preprocess_sentence'][0])[:10]

['quán', 'đồ', 'ăn', 'khá', 'ngon', 'nhưng', 'phục', 'vụ', 'không', 'tốt']


def yield_tokens(sentences, tokenizer):
    for sentence in sentences:
        yield tokenizer(sentence)


from torchtext.vocab import build_vocab_from_iterator

# Build vocabulary
vocab_size = 10000
vocabulary = build_vocab_from_iterator(
    yield_tokens(train_df_vi['preprocess_sentence'], tokenizer),
    max_tokens = vocab_size,
    specials   = ["<unk>"]
)
vocabulary.set_default_index(vocabulary["<unk>"])


from torchtext.data.functional import to_map_style_dataset

# Function to prepare a dataset by encoding sentences into numerical indices and pairing them with labels
def prepare_dataset(df):
    for index, row in df.iterrows():
        sentence = row['preprocess_sentence']
        encoded_sentence = vocabulary(tokenizer(sentence))
        label = row['label']
        yield encoded_sentence, label


# Prepare and convert the training dataset
train_dataset = prepare_dataset(train_df_vi)
train_dataset = to_map_style_dataset(train_dataset)

# Prepare and convert the validation dataset
valid_dataset = prepare_dataset(valid_df)
valid_dataset = to_map_style_dataset(valid_dataset)


# Print the first element of the training dataset to check format and correctness
print(next(iter(train_dataset)))

([6, 45, 1, 42, 10, 16, 47, 39, 5, 225, 69, 812, 1220, 4248, 5, 67, 156, 127, 60, 45, 1, 79, 12, 141, 72, 83, 69, 3, 104, 163, 329, 15, 125, 34, 72, 83, 69, 3, 268, 472, 8, 814, 83, 2, 241, 41, 141, 17, 171, 113, 7, 580, 260, 3, 185, 239, 231, 285, 5, 57, 185, 239, 47, 39, 303, 77, 19, 4, 40, 363, 183, 132, 6], 0)


# Get the length of the training dataset (useful for understanding dataset size and iterations needed in training)
len(train_dataset)

29736


import torch

# Device setup
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")


def collate_batch(batch):
    # Initialize three lists:
    # encoded_sentences: to store the tokenized sentences
    # labels: to store the labels of each sentence
    # offsets: to store the cumulative lengths of sentences (initially starting with 0)
    encoded_sentences, labels, offsets = [], [], [0]
    
    # Iterate over each item in the batch
    for encoded_sentence, label in batch:
        # Append the label to the labels list
        labels.append(label)
        
        # Convert the encoded sentence (list of token indices) to a torch tensor of type int64
        encoded_sentence = torch.tensor(encoded_sentence, dtype=torch.int64)
        
        # Append the tensor to the encoded_sentences list
        encoded_sentences.append(encoded_sentence)
        
        # Append the length of the current sentence to the offsets list
        offsets.append(encoded_sentence.size(0))
    
    # Convert the labels list to a torch tensor of type int64
    labels = torch.tensor(labels, dtype=torch.int64)
    
    # Create the offsets tensor by computing the cumulative sum of the sentence lengths
    # The offsets tensor is used to indicate the starting index of each sentence in the flattened tensor
    offsets = torch.tensor(offsets[:-1]).cumsum(dim=0)
    
    # Concatenate all encoded sentences into a single tensor
    encoded_sentences = torch.cat(encoded_sentences)
    
    # Move the tensors to the specified device (CPU or GPU) and return them
    return encoded_sentences.to(device), offsets.to(device), labels.to(device)


from torch.utils.data import DataLoader

# Set the batch size for the DataLoader
batch_size = 128

# Initialize the DataLoader for the training dataset
train_dataloader = DataLoader(
    train_dataset,            # The dataset to load data from
    batch_size=batch_size,    # The number of samples per batch to load
    shuffle=True,             # Whether to shuffle the data at every epoch
    collate_fn=collate_batch  # Function to merge a list of samples to form a mini-batch
)

# Initialize the DataLoader for the validation dataset
valid_dataloader = DataLoader(
    valid_dataset,            # The dataset to load data from
    batch_size=batch_size,    # The number of samples per batch to load
    shuffle=False,            # Whether to shuffle the data (not needed for validation/testing)
    collate_fn=collate_batch  # Function to merge a list of samples to form a mini-batch
)


# Print the first batch from the training DataLoader to check format and correctness
next(iter(train_dataloader))

(tensor([  45,    1,   53,  ..., 1537, 2021, 4194]),
 tensor([    0,    30,    73,   112,   142,   248,   608,   997,  1040,  1108,
          1252,  1348,  1390,  1404,  1655,  1707,  1763,  1848,  1916,  1985,
          2303,  2343,  2402,  2493,  2535,  2674,  2751,  2814,  2880,  2999,
          3181,  3227,  3450,  3507,  3618,  3709,  3743,  3767,  3784,  3840,
          3999,  4139,  4237,  4432,  4553,  4677,  4725,  4785,  5023,  5114,
          5129,  5218,  5258,  5715,  5772,  5862,  5898,  6046,  6118,  6281,
          6304,  6388,  6465,  6544,  6606,  6638,  6701,  6767,  6842,  6953,
          6982,  7093,  7277,  7290,  7382,  7491,  7539,  7569,  7625,  7663,
          7733,  7779,  7874,  7905,  8008,  8029,  8062,  8095,  8129,  8178,
          8287,  8349,  8935,  9029,  9103,  9290,  9325,  9356,  9406,  9490,
          9731,  9755,  9895, 10028, 10142, 10160, 10186, 10268, 10384, 10591,
         10713, 10736, 10866, 10901, 10996, 11031, 11156, 11235, 11288, 11313,
         11423, 11438, 11482, 12070, 12108, 12223, 12302, 12380]),
 tensor([0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0,
         0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0,
         0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0,
         0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1,
         0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0,
         0, 1, 0, 0, 1, 1, 0, 1]))


# Retrieve the first batch of encoded sentences, offsets, and labels from the training DataLoader
encoded_sentences, offsets, labels = next(iter(train_dataloader))

# Check the shape of the encoded sentences tensor
encoded_sentences.shape

torch.Size([12907])


from sklearn.feature_extraction.text import CountVectorizer
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import accuracy_score, classification_report, classification_report, confusion_matrix


# Combine the training and validation data
combined_df = pd.concat([train_df_vi, valid_df])


# Initialize CountVectorizer
vectorizer = CountVectorizer()

# Fit the vectorizer on the combined data and transform the text data into numerical features
X = vectorizer.fit_transform(combined_df['preprocess_sentence'])

# Extract the labels
y = combined_df['label']


# Split the data into training and validation sets
X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.2, random_state=42)


# Initialize the MultinomialNB classifier
nb_classifier = MultinomialNB()

# Train the classifier on the training data
nb_classifier.fit(X_train, y_train)

MultinomialNB()

MultinomialNB()


# Predicting the Test set results
y_predict_test = nb_classifier.predict(X_valid)
cm = confusion_matrix(y_valid, y_predict_test)
sns.heatmap(cm, annot = True)

<Axes: >


# Predict the labels for the validation set
y_pred = nb_classifier.predict(X_valid)

# Calculate the accuracy of the predictions
accuracy = accuracy_score(y_valid, y_pred)

# Print the accuracy
print(f'Validation Accuracy: {accuracy:.4f}')

# Print a detailed classification report
print('Classification Report:')
print(classification_report(y_valid, y_pred))

Validation Accuracy: 0.8499
Classification Report:
              precision    recall  f1-score   support

           0       0.90      0.79      0.84      4024
           1       0.81      0.91      0.86      3924

    accuracy                           0.85      7948
   macro avg       0.85      0.85      0.85      7948
weighted avg       0.86      0.85      0.85      7948


from torch import nn

# Define the TextClassificationModel class inheriting from nn.Module
class TextClassificationModel(nn.Module):
    # Initialize the model with vocabulary size, embedding dimension, and number of classes
    def __init__(self, vocab_size, embed_dim, num_class):
        super(TextClassificationModel, self).__init__()
        
        # EmbeddingBag layer for converting word indices to embeddings and averaging them
        self.embedding = nn.EmbeddingBag(vocab_size, embed_dim, sparse=False)
        
        # Linear layer for transforming the averaged embeddings to class scores
        self.fc = nn.Linear(embed_dim, num_class)
        
        # Initialize the weights of the layers
        self.init_weights()
    
    # Method to initialize weights of the layers
    def init_weights(self):
        initrange = 0.5
        
        # Initialize embedding layer weights with uniform distribution
        self.embedding.weight.data.uniform_(-initrange, initrange)
        
        # Initialize linear layer weights with uniform distribution
        self.fc.weight.data.uniform_(-initrange, initrange)
        
        # Initialize linear layer bias with zeros
        self.fc.bias.data.zero_()
    
    # Define the forward pass of the model
    def forward(self, inputs, offsets):
        # Get the embedded representation of inputs, averaged based on offsets
        embedded = self.embedding(inputs, offsets)
        
        # Pass the embedded representation through the linear layer
        return self.fc(embedded)


# Determine the number of classes from the training data labels
num_class = len(set(train_df_vi['label']))

# Determine the size of the vocabulary
vocab_size = len(vocabulary)

# Set the embedding dimension
embed_dim = 256

# Instantiate the model and move it to the specified device (CPU or GPU)
model = TextClassificationModel(vocab_size, embed_dim, num_class).to(device)


# Set the learning rate for the optimizer
learning_rate = 2e-5

# Define the loss function: CrossEntropyLoss
criterion = torch.nn.CrossEntropyLoss()

# Define the optimizer: Stochastic Gradient Descent (SGD)
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)


import time

# Define the training function
def train(model, optimizer, criterion, train_dataloader, epoch = 0, log_interval = 25):
    # Set the model to training mode
    model.train()
    
    # Initialize variables to track accuracy and loss
    total_acc, total_count = 0, 0
    losses = []
    
    # Record the start time for tracking training duration
    start_time = time.time()
    
    # Iterate over batches of data from the DataLoader
    for idx, (inputs, offsets, labels) in enumerate(train_dataloader):
        # Zero the gradients of the optimizer
        optimizer.zero_grad()
        
        # Forward pass: compute the model's predictions
        predictions = model(inputs, offsets)
        
        # Compute the loss
        loss = criterion(predictions, labels)
        
        # Append the loss to the list of losses for tracking
        losses.append(loss.item())
        
        # Backward pass: compute the gradients
        loss.backward()
        
        # Clip gradients to prevent exploding gradients
        torch.nn.utils.clip_grad_norm_(model.parameters(), 0.1)
        
        # Update the model parameters
        optimizer.step()
        
        # Update the total accuracy and count
        total_acc += (predictions.argmax(1) == labels).sum().item()
        total_count += labels.size(0)
        
        # Log the training progress at specified intervals
        if idx % log_interval == 0 and idx > 0:
            elapsed = time.time() - start_time
            print(
                "| epoch {:3d} | {:5d}/{:5d} batches ".format(epoch, idx, len(train_dataloader)),
                "| accuracy {:8.3f}".format(total_acc / total_count)
            )
            # Reset the accuracy and count for the next interval
            total_acc, total_count = 0, 0
            start_time = time.time()
    
    # Compute the average accuracy and loss for the epoch
    epoch_acc = total_acc / total_count
    epoch_loss = sum(losses) / len(losses)
    
    return epoch_acc, epoch_loss


# Define the evaluation function
def evaluate(model, criterion, valid_dataloader):
    # Set the model to evaluation mode
    model.eval()
    
    # Initialize variables to track accuracy and loss
    total_acc, total_count = 0, 0
    losses = []
    
    # Disable gradient computation for evaluation
    with torch.no_grad():
        # Iterate over batches of data from the DataLoader
        for idx, (inputs, offsets, labels) in enumerate(valid_dataloader):
            # Forward pass: compute the model's predictions
            predictions = model(inputs, offsets)
            
            # Compute the loss
            loss = criterion(predictions, labels)
            
            # Append the loss to the list of losses for tracking
            losses.append(loss.item())
            
            # Update the total accuracy and count
            total_acc += (predictions.argmax(1) == labels).sum().item()
            total_count += labels.size(0)
    
    # Compute the average accuracy and loss for the epoch
    epoch_acc = total_acc / total_count
    epoch_loss = sum(losses) / len(losses)
    
    return epoch_acc, epoch_loss


# Determine the number of classes from the training data labels
num_class = len(set(train_df_vi['label']))

# Determine the size of the vocabulary
vocab_size = len(vocabulary)

# Set the embedding dimension
embed_dim = 100

# Initialize the model with the determined parameters and move it to the specified device (CPU or GPU)
model = TextClassificationModel(vocab_size, embed_dim, num_class).to(device)

# Set the learning rate for the optimizer
learning_rate = 5

# Define the loss function
# CrossEntropyLoss combines nn.LogSoftmax() and nn.NLLLoss() in one single class
criterion = torch.nn.CrossEntropyLoss()

# Define the optimizer
# Stochastic Gradient Descent (SGD) is a simple and widely used optimization algorithm
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

# Set the number of epochs for training
num_epochs = 20

# Training loop over the specified number of epochs
for epoch in range(1, num_epochs + 1):
    # Record the start time of the epoch
    epoch_start_time = time.time()
    
    # Train the model for one epoch and obtain training accuracy and loss
    train_acc, train_loss = train(model, optimizer, criterion, train_dataloader, epoch)
    
    # Evaluate the model on the validation set and obtain validation accuracy and loss
    eval_acc, eval_loss = evaluate(model, criterion, valid_dataloader)
    
    # Print the end-of-epoch results
    print("-" * 59)
    print(
        "| End of epoch {:3d} | Time: {:5.2f}s | Train Accuracy {:8.3f} | Train Loss {:8.3f} "
        "| Valid Accuracy {:8.3f} | Valid Loss {:8.3f} ".format(
            epoch, time.time() - epoch_start_time, train_acc, train_loss, eval_acc, eval_loss
        )
    )
    print("-" * 59)

| epoch  20 |   150/  233 batches  | accuracy    0.894
| epoch  20 |   175/  233 batches  | accuracy    0.901
| epoch  20 |   200/  233 batches  | accuracy    0.903
| epoch  20 |   225/  233 batches  | accuracy    0.897
-----------------------------------------------------------
| End of epoch  20 | Time:  1.02s | Train Accuracy    0.894 | Train Loss    0.271 | Valid Accuracy    0.870 | Valid Loss    0.349 
-----------------------------------------------------------


# Define the prediction function
def predict(text):
    with torch.no_grad():
        # Tokenize and encode the text
        encoded = torch.tensor(vocabulary(tokenizer(text)))
        # Pass the encoded text through the model
        output = model(encoded, torch.tensor([0]))
        # Return the predicted class
        return output.argmax(1).item()


# Random sample from test_df
import random

# Get a random index and print the review out
index = random.randint(1, 10000)
test_df.iloc[index]

sentence               Ở đây quán khá vắng khách ... không_gian rộng_...
label                                                                  0
preprocess_sentence    ở đây quán khá vắng khách không gian rộng rãi ...
Name: 4399, dtype: object


# Testing the model prediction from random sample
predict(test_df.iloc[index]['sentence'])

0


# Initialize lists to store predictions and true labels
predictions, labels = [], []

# Iterate over each row in the test dataset
for index, row in test_df.iterrows():
    # Extract the preprocessed sentence and the true label from the row
    sentence = row['preprocess_sentence'] 
    label = row['label']
    
    # Predict the label for the sentence using the predict function
    prediction = predict(sentence)
    
    # Append the predicted label to the predictions list
    predictions.append(prediction)
    
    # Append the true label to the labels list
    labels.append(label)

# Calculate the accuracy by comparing predictions with true labels and taking the mean
accuracy = sum(torch.tensor(predictions) == torch.tensor(labels)) / len(labels)
print(f"Accuracy on the test set is: {accuracy:.4f}")

Accuracy on the test set is: 0.8771

	sentence	label
0	Quán đồ_ăn khá ngon . . nhưng phục_vụ không tố...	0
1	Hôm_nay đi ăn tại quán , món ăn ngon vừa_miệng...	0
2	Qua ́ n cư ̣ c ngon . Tuâ ̀ n na ̀ o mi ̀ nh c...	0
3	Chán , đồ uống khá nhạt . Với không_gian và ch...	0
4	Mì ăn ok 👍 🏻 👍 🏻 👍 🏻 nhưng nguội , view rộng ,...	0
5	Bữa có ghé đây ăn , súp chỉ bán tô , 1 tô 15k ...	0
6	Tối mình có mua tàu_hũ bên này . Combo 2 bao_g...	0
7	- Vị_trí : Đường vào thì khá dễ tìm nhưng khi ...	0
8	Ngoài không_gian thoáng_đãng , rộng_rãi . Quán...	0
9	Uwifi quá chậm\n Nhân_viên phục_vụ rất chảnh\n...	0

	sentence	preprocess_sentence
0	Quán đồ_ăn khá ngon . . nhưng phục_vụ không tố...	quán đồ ăn khá ngon nhưng phục vụ không tốt ch...
1	Hôm_nay đi ăn tại quán , món ăn ngon vừa_miệng...	hôm nay đi ăn tại quán món ăn ngon vừa miệng k...
2	Qua ́ n cư ̣ c ngon . Tuâ ̀ n na ̀ o mi ̀ nh c...	qua ́ n cư ̣ c ngon tuâ ̀ n na ̀ o mi ̀ nh cu ...
3	Chán , đồ uống khá nhạt . Với không_gian và ch...	chán đồ uống khá nhạt với không gian và chất l...
4	Mì ăn ok 👍 🏻 👍 🏻 👍 🏻 nhưng nguội , view rộng ,...	mì ăn ok nhưng nguội view rộng nhưng kêu món v...
5	Bữa có ghé đây ăn , súp chỉ bán tô , 1 tô 15k ...	bữa có ghé đây ăn súp chỉ bán tô tô k không gi...
6	Tối mình có mua tàu_hũ bên này . Combo 2 bao_g...	tối mình có mua tàu hũ bên này combo bao gồm t...
7	- Vị_trí : Đường vào thì khá dễ tìm nhưng khi ...	vị trí đường vào thì khá dễ tìm nhưng khi tìm ...
8	Ngoài không_gian thoáng_đãng , rộng_rãi . Quán...	ngoài không gian thoáng đãng rộng rãi quán chẳ...
9	Uwifi quá chậm\n Nhân_viên phục_vụ rất chảnh\n...	uwifi quá chậm nhân viên phục vụ rất chảnh quá...

Project: Text Sentiment Analysis using Naive Bayes Classifier and Neural Network Models¶

I. Introduction¶

II. Dataset Information¶

III. Project Framework¶

IV. Project Implementation¶

1. Import Neccesary Libraries¶

2. Data Cloning and Loading¶

3. Exploratory Data Analysis (EDA)¶

4. Data Preprocessing¶

a. Extract Vietnamese Comments Only¶

b. Data Cleaning¶

5. Text Representation¶

a. Initialize a Tokenizer¶

b. Define a Token Generator¶

c. Build the Vocabulary¶

d. Convert to Torchtext Dataset¶

e. Verify the Dataset¶

6. Data Loader¶

a. Device Setup¶

b. Collate Function¶

c. DataLoader Initialization¶

d. Verify DataLoader¶

7. Naive Bayes Classification¶

a. Import Required Libraries¶

b. Prepare the Data¶

c. Vectorization¶

d. Split the Data¶

e. Train the Naive Bayes Classifier¶

f. Evaluate the Classifier¶

8. Neural Network Model¶

a. Define the TextClassificationModel¶

b. Initialize Model Parameters¶

c. Define the Loss Function and Optimizer¶

d. Define the Training Function¶

e. Define the Evaluation Function¶

f. Training Loop¶

g. Define the Predict Function¶

h. Evaluate Accuracy on Test Set¶

V. Conclusion¶